// pages/roomSharingAdd/roomSharingAdd.js
const api = require("../../config/api.js");
const util = require("../../utils/util.js");
const shareCard = require("../../utils/shareCard.js");

Page({
  /**
   * 页面的初始数据
   */
  data: {
    formData: {
      address: "", // 位置
      bag: 0, // 板包数量
      beginTime: "", // 入住时间
      detail: "", // 详情信息
      endTime: "", // 退房时间
      homeType: "0", // 房型 0：双床 1：大床 2：3人 3：4人（默认值为0）
      limitSex: 0, // 要求性别 0:男 1:女 2:不限
      phone: "", // 电话
      price: "", // 拼房费用
      ski: 0, // 0:单房 1:住滑
      type: 0, // 0:房找人 1:人找房
      wechat: "", // 微信
      longitude: null, // 经度
      latitude: null, // 纬度
      locationName: "" // 位置地址
    },
    // 选择器相关
    showDatePicker: false,
    currentDate: new Date().getTime(),
    minDate: new Date().getTime(),
    // 成功弹窗相关
    showSuccessPopup: false,
    // 房型选项
    roomTypeOptions: [
      { label: "双床", value: "0" },
      { label: "大床", value: "1" },
      { label: "3人", value: "2" },
      { label: "4人", value: "3" }
    ],
    // 住宿类型选项
    accommodationOptions: [
      { label: "单房", value: 0 },
      { label: "住滑", value: 1 }
    ],
    // 性别选项
    genderOptions: [
      { label: "男", value: 0 },
      { label: "女", value: 1 },
      { label: "不限", value: 2 }
    ],
    // 雪场列表
    skiResortList: [],
    // 选中的雪场
    selectedSkiResort: null,
    // 雪场选择器显示状态
    showSkiResortPicker: false,
    // SkiDropdown组件相关
    skiDropdownOpen: false,
    skiDropdownTop: 0,
    selectedSkiId: null, // 当前选中的雪场ID，用于回显和传递给组件
    // 时间选择相关
    showTimeCalendar: false,
    // 编辑模式相关
    editId: null,
    isEditMode: false,
    // 提交按钮文案
    submitButtonText: '提交',
    // 发布成功后返回的ID
    publishedId: null,
    // 分享卡片图片路径
    shareCardImageUrl: null
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log("拼房信息新增页面加载完成", options);
    
    // 处理编辑模式 - 如果有id参数，则获取详情数据回显
    if (options.id) {
      this.setData({
        editId: options.id,
        isEditMode: true,
        submitButtonText: '更新'
      })
      // 设置页面标题为"编辑拼房"
      wx.setNavigationBarTitle({
        title: '编辑拼房'
      })
      this.loadRoomSharingDetail(options.id)
    } 
    // 处理再发一单模式 - 如果有copyId参数，则加载数据并回填（但不设置编辑模式）
    else if (options.copyId) {
      // 设置页面标题为"发布拼房"
      wx.setNavigationBarTitle({
        title: '发布拼房'
      })
      // 加载数据并回填，但不设置编辑模式
      this.loadRoomSharingDetailForCopy(options.copyId)
    } 
    else {
      // 设置页面标题为"发布拼房"
      wx.setNavigationBarTitle({
        title: '发布拼房'
      })
      
      // 处理从home页面传递的参数
      // sex参数：0表示男，1表示女（对应limitSex字段）
      // type参数：0表示房找人，1表示人找房
      if (options.sex !== undefined) {
        const sex = parseInt(options.sex);
        // limitSex: 0=男, 1=女, 2=不限
        // 如果sex是0或1，直接使用；否则保持默认值0
        const limitSex = (sex === 0 || sex === 1) ? sex : 0;
        this.setData({
          'formData.limitSex': limitSex
        });
        console.log('设置性别要求:', limitSex === 0 ? '男' : limitSex === 1 ? '女' : '不限');
      }
      
      if (options.type !== undefined) {
        const type = parseInt(options.type);
        // type: 0=房找人, 1=人找房
        if (type === 0 || type === 1) {
          this.setData({
            'formData.type': type
          });
          console.log('设置类型:', type === 0 ? '房找人' : '人找房');
        }
      }
    }
    
    // 不再需要加载公共信息，SkiDropdown组件内部会处理数据加载
  },

  /**
   * 返回按钮
   */
  goBack: function () {
    wx.navigateBack();
  },

  /**
   * 加载拼房详情数据
   */
  loadRoomSharingDetail: function(id) {
    const util = require('../../utils/util.js')
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    util.request(api.HomeInfo, {
      id: id
    }, 'POST', 'application/json').then(res => {
      console.log('拼房详情响应:', res)
      
      const normalizedRes = util.normalizeApiResponse(res)
      
      if (normalizedRes.success && normalizedRes.data) {
        const detailData = normalizedRes.data
        
        // 格式化时间戳为日期字符串的辅助函数
        const formatTimestampToDate = (timestamp) => {
          if (!timestamp) return ''
          try {
            // 判断是秒级时间戳还是毫秒级时间戳
            const date = timestamp < 10000000000 
              ? new Date(timestamp * 1000) 
              : new Date(timestamp)
            
            if (!isNaN(date.getTime())) {
              const year = date.getFullYear()
              const month = String(date.getMonth() + 1).padStart(2, '0')
              const day = String(date.getDate()).padStart(2, '0')
              return `${year}-${month}-${day}`
            }
          } catch (error) {
            console.log('解析时间戳失败:', error)
            // 如果已经是日期字符串格式，直接返回
            if (typeof timestamp === 'string' && timestamp.includes('-')) {
              return timestamp
            }
          }
          return ''
        }
        
        // 回显数据到表单
        // 注意：price和phone需要转换为字符串类型用于输入框显示
        // 使用addressId作为雪场ID字段，skiAddress作为雪场名称字段
        const skiId = detailData.addressId || null
        const skiName = detailData.skiAddress || ''
        
        // 处理时间字段：如果是时间戳，转换为日期字符串
        const beginTime = formatTimestampToDate(detailData.beginTime)
        const endTime = formatTimestampToDate(detailData.endTime)
        
        // 处理房型：确保是字符串类型（因为wxml中比较的是字符串'0'、'1'等）
        const homeType = detailData.homeType !== undefined && detailData.homeType !== null 
          ? String(detailData.homeType) 
          : '0'
        
        this.setData({
          'formData.address': detailData.address || '',
          'formData.bag': detailData.bag || 0,
          'formData.beginTime': beginTime, // 将时间戳转换为日期字符串
          'formData.detail': detailData.detail || '',
          'formData.endTime': endTime, // 将时间戳转换为日期字符串
          'formData.homeType': homeType, // 确保是字符串类型
          'formData.limitSex': detailData.limitSex || 0,
          'formData.phone': detailData.phone ? String(detailData.phone) : '',
          'formData.price': detailData.price ? String(detailData.price) : '',
          'formData.ski': detailData.ski || 0, // ski字段用于是否住滑，不是雪场ID
          'formData.type': detailData.type || 0,
          'formData.wechat': detailData.wechat || '',
          'formData.longitude': detailData.longitude || null,
          'formData.latitude': detailData.latitude || null,
          'formData.locationName': detailData.locationName || '',
          // 设置selectedSkiId和selectedSkiResort用于SkiDropdown回显
          selectedSkiId: skiId,
          selectedSkiResort: skiId ? { id: skiId, name: skiName } : null
        })
        
        console.log('设置雪场ID用于回显:', skiId, '雪场名称:', skiName)
        console.log('时间回显 - beginTime:', beginTime, 'endTime:', endTime)
        console.log('房型回显 - homeType:', homeType)
        console.log('拼房详情加载成功，数据已回显')
        
      } else {
        wx.showToast({
          title: normalizedRes.message || '加载详情失败',
          icon: 'none'
        })
      }
    }).catch(err => {
      console.error('加载拼房详情失败:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    }).finally(() => {
      wx.hideLoading()
    })
  },

  /**
   * 加载拼房详情数据用于再发一单（回填部分数据）
   */
  loadRoomSharingDetailForCopy: function(id) {
    const util = require('../../utils/util.js')
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    util.request(api.HomeInfo, {
      id: id
    }, 'POST', 'application/json').then(res => {
      console.log('拼房详情响应（再发一单）:', res)
      
      const normalizedRes = util.normalizeApiResponse(res)
      
      if (normalizedRes.success && normalizedRes.data) {
        const detailData = normalizedRes.data
        
        // 格式化时间戳为日期字符串的辅助函数
        const formatTimestampToDate = (timestamp) => {
          if (!timestamp) return ''
          try {
            // 判断是秒级时间戳还是毫秒级时间戳
            const date = timestamp < 10000000000 
              ? new Date(timestamp * 1000) 
              : new Date(timestamp)
            
            if (!isNaN(date.getTime())) {
              const year = date.getFullYear()
              const month = String(date.getMonth() + 1).padStart(2, '0')
              const day = String(date.getDate()).padStart(2, '0')
              return `${year}-${month}-${day}`
            }
          } catch (error) {
            console.log('解析时间戳失败:', error)
            // 如果已经是日期字符串格式，直接返回
            if (typeof timestamp === 'string' && timestamp.includes('-')) {
              return timestamp
            }
          }
          return ''
        }
        
        // 再发一单模式：回填所有表单字段（formData中的字段）
        // 回填的表单字段：地址、房型、性别限制、类型、板包、地图坐标、价格、详情、微信号、手机号
        // 不回填的字段：时间范围(beginTime/endTime) - 让用户重新选择
        // 使用addressId作为雪场ID字段，skiAddress作为雪场名称字段
        const skiId = detailData.addressId || null
        const skiName = detailData.skiAddress || ''
        
        // 处理房型：确保是字符串类型（因为wxml中比较的是字符串'0'、'1'等）
        const homeType = detailData.homeType !== undefined && detailData.homeType !== null 
          ? String(detailData.homeType) 
          : '0'
        
        // 回填所有表单字段（formData中的字段）
        this.setData({
          // 表单字段：地址和位置
          'formData.address': detailData.address || '',
          'formData.longitude': detailData.longitude || null,
          'formData.latitude': detailData.latitude || null,
          'formData.locationName': detailData.locationName || '',
          // 表单字段：房型和限制（确保homeType是字符串类型）
          'formData.homeType': homeType,
          'formData.limitSex': detailData.limitSex || 0,
          'formData.ski': detailData.ski || 0, // ski字段用于是否住滑，不是雪场ID
          'formData.type': detailData.type || 0,
          // 表单字段：板包
          'formData.bag': detailData.bag || 0,
          // 表单字段：价格、详情、联系方式（再发一单时也回填）
          'formData.price': detailData.price ? String(detailData.price) : '',
          'formData.detail': detailData.detail || '',
          'formData.wechat': detailData.wechat || '',
          'formData.phone': detailData.phone ? String(detailData.phone) : '',
          // UI状态字段（用于组件回显，不是表单字段）
          selectedSkiId: skiId,
          selectedSkiResort: skiId ? { id: skiId, name: skiName } : null
        })
        
        // 注意：时间范围(beginTime/endTime)不回填，让用户重新选择
        
        console.log('再发一单：设置雪场ID用于回显:', skiId, '雪场名称:', skiName)
        console.log('再发一单：房型回显 - homeType:', homeType)
        console.log('再发一单：数据回填完成')
        
      } else {
        wx.showToast({
          title: normalizedRes.message || '加载详情失败',
          icon: 'none'
        })
      }
    }).catch(err => {
      console.error('加载拼房详情失败（再发一单）:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    }).finally(() => {
      wx.hideLoading()
    })
  },

  /**
   * 显示日期选择器
   */
  showDatePicker: function () {
    this.setData({
      showDatePicker: true
    });
  },

  /**
   * 显示地点选择器 - 使用地图选点
   */
  showLocationPicker: function (e) {
    // 使用微信地图选点API
    wx.chooseLocation({
      success: (res) => {
        console.log("选择的地点信息:", res);
        // address 存储 res.name，locationName 存储 res.address
        // 注意：如果 res.name 不存在，address 使用 res.address 作为备选（保持向后兼容）
        this.setData({
          "formData.address": res.name || res.address || '', // address 优先使用 res.name
          "formData.longitude": res.longitude || null,
          "formData.latitude": res.latitude || null,
          "formData.locationName": res.address || '' // locationName 存储 res.address
        });
      },
      fail: (error) => {
        console.log("取消选择地点或选择失败:", error);
        // 用户取消选择时不显示错误提示
        if (error.errMsg !== "chooseLocation:fail cancel") {
          wx.showToast({
            title: "选择地点失败",
            icon: "none"
          });
        }
      }
    });
  },


  /**
   * 显示雪场选择器 - 使用SkiDropdown组件
   */
  showSkiResortPicker: function () {
    // 获取当前已选中的雪场ID（用于回显）
    const selectedSkiId = this.data.selectedSkiId || (this.data.selectedSkiResort ? this.data.selectedSkiResort.id : null)
    
    // 获取系统信息，计算从底部出现的位置
    const systemInfo = wx.getSystemInfoSync()
    const panelHeight = 320 // SkiDropdown组件高度
    const top = systemInfo.windowHeight - panelHeight
    
    this.setData({
      skiDropdownOpen: true,
      skiDropdownTop: top,
      selectedSkiId: selectedSkiId
    })
  },

  /**
   * 关闭雪场选择器
   */
  closeSkiDropdown: function() {
    this.setData({
      skiDropdownOpen: false
    })
  },

  /**
   * SkiDropdown组件change事件处理（单选模式）
   */
  onSkiDropdownChange: function(e) {
    const optionId = e.detail.value
    const optionName = e.detail.name
    
    // 处理"不限"选项：optionId为null时重置（虽然showAllOption=false，但保留此逻辑以防万一）
    if (optionId === null || optionId === undefined || optionId === '') {
      this.setData({
        selectedSkiResort: null,
        selectedSkiId: null
      })
      console.log('清空选择的雪场')
      return
    }
    
    if (!optionId) {
      console.warn('选择雪场时缺少ID')
      return
    }
    
    // 确保optionName存在，如果不存在则使用optionId作为默认值
    const displayName = optionName || `雪场${optionId}`
    
    const selectedSkiResort = {
      id: optionId,
      name: displayName
    }
    
    // 更新selectedSkiResort和selectedSkiId
    // 注意：formData.ski字段用于"是否住滑"，不是雪场ID，雪场ID保存在selectedSkiId中，提交时转换为addressId
    this.setData({
      selectedSkiResort: selectedSkiResort,
      selectedSkiId: optionId
    })
    
    console.log("选择的雪场:", {
      id: optionId,
      name: displayName
    })
  },

  /**
   * 选择房型
   */
  selectRoomType: function (e) {
    const type = e.currentTarget.dataset.type;
    this.setData({
      "formData.homeType": type
    });
  },

  /**
   * 选择住宿类型
   */
  selectAccommodation: function (e) {
    const type = parseInt(e.currentTarget.dataset.type);
    this.setData({
      "formData.ski": type
    });
  },

  /**
   * 选择性别要求
   */
  selectGender: function (e) {
    const gender = e.currentTarget.dataset.gender;
    const genderMap = {
      男: 0,
      女: 1,
      不限: 2
    };
    this.setData({
      "formData.limitSex": genderMap[gender]
    });
  },

  /**
   * 输入框内容变化
   */
  onInputChange: function (e) {
    const field = e.currentTarget.dataset.field;
    let value = e.detail.value;
    
    // 如果是价格字段，确保输入的是有效的数字
    if (field === 'price' && value !== '') {
      // 只允许数字和小数点
      value = value.replace(/[^\d.]/g, '');
      // 确保只有一个小数点
      const parts = value.split('.');
      if (parts.length > 2) {
        value = parts[0] + '.' + parts.slice(1).join('');
      }
      // 限制最大值为9999
      const numValue = parseFloat(value);
      if (!isNaN(numValue) && numValue > 9999) {
        value = '9999';
        wx.showToast({
          title: '拼房费用不能超过9999',
          icon: 'none',
          duration: 2000
        });
      }
    }
    
    // 如果是电话字段，只允许输入数字，并限制长度为11位
    if (field === 'phone') {
      // 只允许数字，过滤掉所有非数字字符（包括中文）
      value = value.replace(/[^\d]/g, '');
      // 限制最大长度为11位
      if (value.length > 11) {
        value = value.substring(0, 11);
        wx.showToast({
          title: '手机号只能输入11位',
          icon: 'none',
          duration: 1500
        });
      }
    }
    
    // 如果是微信号字段，仅不能输入汉字，其他字符都可以输入
    if (field === 'wechat') {
      // 过滤掉汉字（Unicode范围：\u4e00-\u9fa5），其他字符都可以输入
      value = value.replace(/[\u4e00-\u9fa5]/g, '');
      // 限制最大长度为20个字符
      if (value.length > 20) {
        value = value.substring(0, 20);
        wx.showToast({
          title: '微信号最多20个字符',
          icon: 'none',
          duration: 1500
        });
      }
    }
    
    this.setData({
      [`formData.${field}`]: value
    });
  },

  /**
   * 显示时间选择器
   */
  showTimePicker: function () {
    this.setData({
      showTimeCalendar: true
    });
  },

  /**
   * 时间日历关闭
   */
  onTimeCalendarClose: function () {
    this.setData({
      showTimeCalendar: false
    });
  },

  /**
   * 时间日历确认选择
   */
  onTimeCalendarConfirm: function (e) {
    console.log("选择的时间范围:", e.detail);
    const [startDate, endDate] = e.detail;

    // 格式化日期
    const formatDate = (date) => {
      const d = new Date(date);
      const year = d.getFullYear();
      const month = String(d.getMonth() + 1).padStart(2, "0");
      const day = String(d.getDate()).padStart(2, "0");
      return `${year}-${month}-${day}`;
    };

    this.setData({
      "formData.beginTime": formatDate(startDate),
      "formData.endTime": formatDate(endDate),
      showTimeCalendar: false
    });

    console.log("设置的时间:", {
      beginTime: formatDate(startDate),
      endTime: formatDate(endDate)
    });
  },

  /**
   * 日期选择器相关方法
   */
  onDateChange: function (e) {
    this.setData({
      currentDate: e.detail
    });
  },

  onDateConfirm: function (e) {
    const date = new Date(e.detail);
    const dateStr = `${date.getFullYear()}-${String(
      date.getMonth() + 1
    ).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
    this.setData({
      "formData.beginTime": dateStr,
      showDatePicker: false
    });
  },

  onDateCancel: function () {
    this.setData({
      showDatePicker: false
    });
  },

  onDatePickerClose: function () {
    this.setData({
      showDatePicker: false
    });
  },

  /**
   * 提交表单
   */
  handleSubmit: function () {
    const { formData } = this.data;

    // 表单验证
    if (!formData.address) {
      wx.showToast({
        title: "请选择位置",
        icon: "none"
      });
      return;
    }

    // 验证雪场是否已选择
    if (!this.data.selectedSkiId || this.data.selectedSkiId === null || this.data.selectedSkiId === '') {
      wx.showToast({
        title: "请选择雪场",
        icon: "none"
      });
      return;
    }

    if (!formData.homeType) {
      wx.showToast({
        title: "请选择房型",
        icon: "none"
      });
      return;
    }

    if (!formData.beginTime) {
      wx.showToast({
        title: "请选择入住时间",
        icon: "none"
      });
      return;
    }

    // 验证价格是否为有效的正数
    if (!formData.price || formData.price === '' || Number(formData.price) <= 0) {
      wx.showToast({
        title: "请输入拼房费用",
        icon: "none"
      });
      return;
    }

    if (!formData.wechat) {
      wx.showToast({
        title: "请输入微信",
        icon: "none"
      });
      return;
    }
    
    // 如果填写了电话，必须至少11位
    if (formData.phone && formData.phone.length > 0 && formData.phone.length < 11) {
      wx.showToast({
        title: '手机号不能少于11位',
        icon: 'none'
      });
      return;
    }

    // 在提交前进行登录校验
    const that = this
    
    // 点击提交时缓存表单数据（无论是否登录）
    this.cacheFormData()
    
    util.executeWithLoginCheck(
      () => {
        // 用户已登录，执行提交
        if (that.data.isEditMode) {
          that.updateRoomSharing(formData)
        } else {
          that.addRoomSharing(formData)
        }
      },
      "发布拼房信息需要先登录，是否立即登录？",
      "/pages/roomSharingAdd/roomSharingAdd"
    )
  },

  /**
   * 缓存表单数据
   */
  cacheFormData: function() {
    const cacheKey = 'roomSharingAdd_formData_cache'
    const formData = JSON.parse(JSON.stringify(this.data.formData))
    // 同时缓存雪场选择信息
    const cacheData = {
      formData: formData,
      selectedSkiId: this.data.selectedSkiId,
      selectedSkiResort: this.data.selectedSkiResort
    }
    wx.setStorageSync(cacheKey, cacheData)
    console.log('已缓存拼房表单数据:', cacheData)
  },

  /**
   * 恢复缓存的表单数据
   */
  restoreFormData: function() {
    const cacheKey = 'roomSharingAdd_formData_cache'
    const cachedData = wx.getStorageSync(cacheKey)
    
    if (cachedData) {
      console.log('恢复缓存的拼房表单数据:', cachedData)
      this.setData({
        formData: cachedData.formData || cachedData,
        selectedSkiId: cachedData.selectedSkiId,
        selectedSkiResort: cachedData.selectedSkiResort
      })
      // 恢复后清除缓存
      wx.removeStorageSync(cacheKey)
    }
  },

  /**
   * 更新拼房接口调用
   */
  updateRoomSharing: function (formData) {
    const util = require('../../utils/util.js');
    
    // 使用selectedSkiId作为雪场ID
    const addressId = this.data.selectedSkiId || null
    // 使用selectedSkiResort获取雪场名称
    const skiAddress = this.data.selectedSkiResort?.name || ''
    
    const updateData = {
      id: this.data.editId,
      address: formData.address,
      bag: formData.bag || 0,
      beginTime: formData.beginTime,
      detail: formData.detail || "",
      endTime: formData.endTime || "",
      homeType: formData.homeType,
      limieSex: formData.limitSex, // 注意：接口使用limieSex而不是limitSex
      phone: formData.phone || "",
      price: formData.price,
      ski: formData.ski || 0, // ski字段用于是否住滑，不是雪场ID
      addressId: addressId, // 使用addressId作为雪场ID字段
      skiAddress: skiAddress, // 雪场名称
      type: formData.type,
      wechat: formData.wechat
    };
    
    // 添加地图选点相关字段
    if (formData.longitude !== null && formData.longitude !== undefined) {
      updateData.longitude = formData.longitude
    }
    if (formData.latitude !== null && formData.latitude !== undefined) {
      updateData.latitude = formData.latitude
    }
    if (formData.locationName) {
      updateData.locationName = formData.locationName
    }
    
    // 转换价格为数字类型
    if (updateData.price) {
      updateData.price = parseFloat(updateData.price);
    }
    // 转换电话号码为数字类型
    if (updateData.phone) {
      updateData.phone = parseFloat(updateData.phone);
    }
    
    console.log('调用编辑拼房接口，参数:', updateData);
    console.log('接口地址:', api.HomeEdit);
    
    util.request(api.HomeEdit, updateData, 'POST', 'application/json').then(res => {
      console.log('更新拼房响应:', res);
      
      const normalizedRes = util.normalizeApiResponse(res);
      console.log('标准化后的响应:', normalizedRes);
      
      if (normalizedRes.success) {
        // 更新成功后清除缓存数据
        const cacheKey = 'roomSharingAdd_formData_cache'
        wx.removeStorageSync(cacheKey)
        console.log('更新成功，已清除缓存的表单数据')
        
        wx.showToast({
          title: '更新成功',
          icon: 'success'
        });
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      } else {
        wx.showToast({
          title: normalizedRes.message || '更新失败',
          icon: 'none',
          duration: 2000
        });
      }
    }).catch(err => {
      console.error('更新拼房失败:', err);
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      });
    });
  },

  /**
   * 发布拼房接口调用
   */
  addRoomSharing: function (formData) {
    const util = require('../../utils/util.js');
    
    // 使用selectedSkiId作为雪场ID
    const addressId = this.data.selectedSkiId || null
    // 使用selectedSkiResort获取雪场名称
    const skiAddress = this.data.selectedSkiResort?.name || ''
    
    const requestData = {
      address: formData.address,
      bag: formData.bag || 0,
      beginTime: formData.beginTime,
      detail: formData.detail || "",
      endTime: formData.endTime || "",
      homeType: formData.homeType,
      limitSex: formData.limitSex,
      phone: formData.phone || "",
      price: formData.price,
      ski: formData.ski || 0, // ski字段用于是否住滑，不是雪场ID
      addressId: addressId, // 使用addressId作为雪场ID字段
      skiAddress: skiAddress, // 雪场名称
      type: formData.type,
      wechat: formData.wechat
    };
    
    // 添加地图选点相关字段
    if (formData.longitude !== null && formData.longitude !== undefined) {
      requestData.longitude = formData.longitude
    }
    if (formData.latitude !== null && formData.latitude !== undefined) {
      requestData.latitude = formData.latitude
    }
    if (formData.locationName) {
      requestData.locationName = formData.locationName
    }
    
    util.request(api.RoomAdd, requestData, 'POST', 'application/json').then(res => {
      console.log('发布拼房响应:', res);
      
      // 使用标准化的响应处理
      const normalizedRes = util.normalizeApiResponse(res);
      console.log('标准化后的响应:', normalizedRes);
      
      if (normalizedRes.success) {
        // 提交成功后清除缓存数据
        const cacheKey = 'roomSharingAdd_formData_cache'
        wx.removeStorageSync(cacheKey)
        console.log('提交成功，已清除缓存的表单数据')
        
        const publishedId = normalizedRes.data?.id || normalizedRes.data || null;
        // 显示成功弹窗，保存返回的ID
        this.setData({
          showSuccessPopup: true,
          publishedId: publishedId
        });
      } else {
        wx.showToast({
          title: normalizedRes.message || '发布失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('发布拼房失败:', err);
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      });
    });
  },

  /**
   * 关闭成功弹窗
   */
  closeSuccessPopup: function () {
    this.setData({
      showSuccessPopup: false
    });
    // 返回上一层页面
    setTimeout(() => {
      wx.navigateBack();
    }, 300);
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function () {
    // 阻止事件冒泡，防止点击弹窗内容时关闭弹窗
  },

  /**
   * 生成分享卡片（预生成并缓存）
   */
  generateShareCard: function(publishedId) {
    const that = this;
    
    if (!publishedId) {
      return Promise.resolve();
    }
    
    // 获取详情数据
    return util.request(api.HomeInfo, { id: publishedId }, 'POST', 'application/json').then((res) => {
      const normalizedRes = util.normalizeApiResponse(res);
      
      if (normalizedRes.success && normalizedRes.data) {
        const homeInfo = normalizedRes.data;
        
        // 格式化时间
        const beginTime = homeInfo.beginTime ? new Date(homeInfo.beginTime) : null;
        const endTime = homeInfo.endTime ? new Date(homeInfo.endTime) : null;
        let timeText = "";
        if (beginTime && endTime) {
          const formatDate = (date) => {
            const month = date.getMonth() + 1;
            const day = date.getDate();
            const weekdays = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
            const weekday = weekdays[date.getDay()];
            return `${month}月${day}日 ${weekday}`;
          };
          timeText = `${formatDate(beginTime)} - ${formatDate(endTime)}`;
        }
        
        // 构建roomInfo数据
        const roomInfo = {
          serviceType: homeInfo.type === 0 ? "房找人" : "人找房",
          time: timeText,
          address: homeInfo.address || "地址待定",
          ski: homeInfo.ski
        };
        
        // 构建homeInfo数据
        const homeInfoData = {
          ski: homeInfo.ski || "0"
        };
        
        // 异步生成分享卡片
        return shareCard.getShareCard('room', {
          id: publishedId,
          roomSharingId: publishedId,
          roomInfo: roomInfo,
          homeInfo: homeInfoData
        }).then((shareConfig) => {
          // 缓存分享卡片图片路径
          that.setData({
            shareCardImageUrl: shareConfig.imageUrl
          });
          // 返回分享配置，供调用方使用
          return shareConfig;
        }).catch((err) => {
          console.error('生成分享卡片失败:', err);
          // 失败时使用基础图
          const fallbackConfig = {
            imageUrl: '/static/images/shareBase.png'
          };
          that.setData({
            shareCardImageUrl: fallbackConfig.imageUrl
          });
          return fallbackConfig;
        });
      } else {
        // 如果获取详情数据失败，返回基础图配置
        const fallbackConfig = {
          imageUrl: '/static/images/shareBase.png'
        };
        that.setData({
          shareCardImageUrl: fallbackConfig.imageUrl
        });
        return Promise.resolve(fallbackConfig);
      }
    }).catch((err) => {
      console.error('获取详情数据失败:', err);
      // 返回基础图配置
      const fallbackConfig = {
        imageUrl: '/static/images/shareBase.png'
      };
      that.setData({
        shareCardImageUrl: fallbackConfig.imageUrl
      });
      return Promise.resolve(fallbackConfig);
    });
  },


  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: async function () {
    const { publishedId, shareCardImageUrl } = this.data;
    
    if (!publishedId) {
      return {
        title: "拼车拼房拼雪票，加入俱乐部社群更有专属福利！",
        path: "/pages/index/index",
        imageUrl: "/static/images/shareBase.png"
      };
    }
    
    // 获取分享配置
    const shareConfig = shareCard.getShareConfig('room', {
      id: publishedId,
      roomSharingId: publishedId,
      roomInfo: {}
    });
    
    // 如果没有缓存的分享卡片，显示loading并同步等待生成完成
    if (!shareCardImageUrl) {
      wx.showLoading({
        title: '生成分享卡片中...',
        mask: true
      });
      try {
        // 同步等待分享卡片生成完成，并获取返回的分享配置
        const generatedConfig = await this.generateShareCard(publishedId);
        // 使用生成的分享卡片图片
        shareConfig.imageUrl = generatedConfig?.imageUrl || '/static/images/shareBase.png';
      } catch (err) {
        console.error('生成分享卡片失败:', err);
        shareConfig.imageUrl = '/static/images/shareBase.png';
      } finally {
        wx.hideLoading();
      }
    } else {
      // 使用缓存的分享卡片图片
      shareConfig.imageUrl = shareCardImageUrl;
    }
    
    return shareConfig;
  },

  /**
   * 处理查看
   */
  handleView: function () {
    const { publishedId } = this.data;
    
    // 关闭弹窗
    this.setData({
      showSuccessPopup: false
    });
    
    setTimeout(() => {
      if (publishedId) {
        // 跳转到详情页
        wx.redirectTo({
          url: `/pages/roomSharingDetail/roomSharingDetail?id=${publishedId}`,
          fail: (err) => {
            console.error('跳转失败:', err);
            wx.navigateBack();
          }
        });
      } else {
        // 如果没有ID，返回上一页
        wx.navigateBack();
      }
    }, 300);
  },

  /**
   * 加入俱乐部
   */
  joinClub: function () {
    // 可以在这里实现加入俱乐部的逻辑
    wx.showToast({
      title: "加入俱乐部功能待实现",
      icon: "none"
    });
  },

  /**
   * 重置表单
   */
  onReset: function () {
    this.setData({
      formData: {
        address: "",
        bag: 0,
        beginTime: "",
        detail: "",
        endTime: "",
        homeType: "",
        limitSex: 0,
        phone: "",
        price: "",
        ski: 0,
        type: 0,
        wechat: ""
      },
      showDatePicker: false,
      showSuccessPopup: false
    });

    wx.showToast({
      title: "已重置",
      icon: "success"
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {
    console.log("拼房信息新增页面渲染完成");
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    console.log("拼房信息新增页面显示");
    
    // 编辑模式下不恢复缓存，因为编辑模式应该显示从服务器加载的数据
    if (this.data.isEditMode) {
      return
    }
    
    // 检查是否有缓存的表单数据（从登录页面返回时恢复）
    const userInfo = wx.getStorageSync('userInfo')
    const token = wx.getStorageSync('token')
    const navUrl = wx.getStorageSync('navUrl')
    
    // 如果用户已登录，检查并恢复缓存的表单数据
    if (userInfo && token) {
      // 如果 navUrl 匹配，清除导航URL
      if (navUrl === '/pages/roomSharingAdd/roomSharingAdd') {
        wx.removeStorageSync('navUrl')
      }
      // 无论 navUrl 是否匹配，都尝试恢复缓存（防止 navUrl 未设置的情况）
      this.restoreFormData()
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {
    console.log("拼房信息新增页面隐藏");
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {
    console.log("拼房信息新增页面卸载");
  },

  /**
   * 页面相关事件处理函数--监听页面滚动
   */
  onPageScroll: function () {
    // 页面滚动时关闭雪场选择下拉组件
    if (this.data.skiDropdownOpen) {
      this.setData({
        skiDropdownOpen: false
      })
    }
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {
    console.log("用户下拉刷新");
    wx.stopPullDownRefresh();
  },

});
